#define F_CPU 8000000UL // 8 MHz
#include <util/delay.h>
#include <avr/io.h> 
#include <util/twi.h>
#define set_input(portdir,pin) portdir &= ~(1<<pin)
#define set_output(portdir,pin) portdir |= (1<<pin)
#define output_high(port,pin) port |= (1<<pin)
#define output_low(port,pin) port &= ~(1<<pin)

#ifndef DEF_LED
#define DEF_LED

class led {
public :
	led();
	~led();
	void allume_ambre();
	void allume_vert();
	void allume_rouge();
	void eteindre();

private :
};

#endif /* DEF_LED*/


#ifndef DEF_CAN
#define DEF_CAN
/*
 * Classe can:
 *   Le constructeur initialise le convertisseur.
 *   Une lecture enclanche une conversion et le resultat
 *   est retourne sur 16 bits.
 *
 */

class can
{
public:

   can();
   ~can();
   // retourne la valeur numerique correspondant a la valeur
   // analogique sur le port A.  pos doit etre entre 0 et 7
   // inclusivement.  Seulement les 10 bits de poids faible
   // sont significatifs.
   uint16_t lecture(uint8_t pos);

private:
   // Donnees membres - aucun

};

#endif /* CAN_H */


#ifndef DEF_ROUEGAUCHE
#define DEF_ROUEGAUCHE

class Rouegauche
{
public:
	Rouegauche(); 
	~Rouegauche();
	void Avancer(int v); 
	void Reculer(int v);

private :
};

#endif //DEF_ROUEGAUCHE


#ifndef DEF_ROUEDROITE
#define DEF_ROUEDROITE

class Rouedroite
{
public:
	Rouedroite() ; 
	~Rouedroite() ; 
	void Avancer(int v); 
	void Reculer(int v);
private :
};

#endif //DEF_ROUEDROITE

#ifndef DEF_MEMOIRE
#define DEF_MEMOIRE

class Memoire24CXXX
{
public:

   Memoire24CXXX(); // le constructeur appelle init() decrit plus bas
   ~Memoire24CXXX();

   // procedure d'initialisation - a appeler avant lecture ou ecriture
   void init();
   
   // la procedure init() initialize a zero le "memory bank". 
   // appeler cette methode uniquement si l'adresse doit changer
   static uint8_t choisir_banc(const uint8_t banc);
   
   // deux variantes pour la lecture, celle-ci et la suivante
   uint8_t lecture(const uint16_t adresse, uint8_t *donnee);

   // longueur doit etre de 127 et moins
   uint8_t lecture(const uint16_t adresse, uint8_t *donnee,
                   const uint8_t longueur);

   // deux variantes pour la l'ecriture egalement
   uint8_t ecriture(const uint16_t adresse, const uint8_t donnee);
   uint8_t ecriture(const uint16_t adresse, uint8_t *donnee,
                    const uint8_t longueur);

private:
   // pour l'ecriture
   uint8_t ecrire_page(const uint16_t adresse, uint8_t *donnee,
                       const uint8_t longueur);

private:
   // donnees membres
   static uint8_t m_adresse_peripherique;
   const uint8_t PAGE_SIZE;
};
#endif /* DEF_MEMOIRE */